package com.gzedu.ecloud.common.utils;

import java.util.LinkedList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public abstract class Strings {
	/**
	 * 如果此字符串为 null 或者为空串（""），则返回 true
	 * 
	 * @param cs
	 *            字符串
	 * @return 如果此字符串为 null 或者为空，则返回 true
	 */
	public static boolean isEmpty(CharSequence str) {
		return str == null || str.length() == 0;
	}

	/**
	 * 检查两个字符串的忽略大小写后是否相等.
	 * 
	 * @param s1
	 *            字符串A
	 * @param s2
	 *            字符串B
	 * @return true 如果两个字符串忽略大小写后相等,且两个字符串均不为null
	 */
	public static boolean equalsIgnoreCase(String s1, String s2) {
		return s1 == null ? s2 == null : s1.equalsIgnoreCase(s2);
	}

	/**
	 * 检查两个字符串是否相等.
	 * 
	 * @param s1
	 *            字符串A
	 * @param s2
	 *            字符串B
	 * @return true 如果两个字符串相等,且两个字符串均不为null
	 */
	public static boolean equals(String s1, String s2) {
		return s1 == null ? s2 == null : s1.equals(s2);
	}

	/**
	 * 如果此字符串为 null 或者全为空白字符，则返回 true
	 * 
	 * @param cs
	 *            字符串
	 * @return 如果此字符串为 null 或者全为空白字符，则返回 true
	 */
	public static boolean isBlank(CharSequence cs) {
		if (null == cs)
			return true;
		int length = cs.length();
		for (int i = 0; i < length; i++) {
			if (!(Character.isWhitespace(cs.charAt(i))))
				return false;
		}
		return true;
	}

	public static boolean isNotBlank(CharSequence cs) {
		return !isBlank(cs);
	}

	/**
	 * 去掉字符串前后空白字符。空白字符的定义由Character.isWhitespace来判断
	 * 
	 * @param cs
	 *            字符串
	 * @return 去掉了前后空白字符的新字符串
	 */
	public static String trim(CharSequence cs) {
		if (null == cs)
			return null;
		int length = cs.length();
		if (length == 0)
			return cs.toString();
		int l = 0;
		int last = length - 1;
		int r = last;
		for (; l < length; l++) {
			if (!Character.isWhitespace(cs.charAt(l)))
				break;
		}
		for (; r > l; r--) {
			if (!Character.isWhitespace(cs.charAt(r)))
				break;
		}
		if (l > r)
			return "";
		else if (l == 0 && r == last)
			return cs.toString();
		return cs.subSequence(l, r + 1).toString();
	}

	/**
	 * 将一个字符串出现的HMTL元素进行转义，比如
	 * 
	 * <pre>
	 *  escapeHtml("&lt;script&gt;alert("hello world");&lt;/script&gt;") => "&amp;lt;script&amp;gt;alert(&amp;quot;hello world&amp;quot;);&amp;lt;/script&amp;gt;"
	 * </pre>
	 * 
	 * 转义字符对应如下
	 * <ul>
	 * <li>& => &amp;amp;
	 * <li>< => &amp;lt;
	 * <li>>=> &amp;gt;
	 * <li>' => &amp;#x27;
	 * <li>" => &amp;quot;
	 * </ul>
	 * 
	 * @param cs
	 *            字符串
	 * 
	 * @return 转换后字符串
	 */
	public static String escapeHtml(CharSequence cs) {
		if (null == cs)
			return null;
		char[] cas = cs.toString().toCharArray();
		StringBuilder sb = new StringBuilder();
		for (char c : cas) {
			switch (c) {
			case '&':
				sb.append("&amp;");
				break;
			case '<':
				sb.append("&lt;");
				break;
			case '>':
				sb.append("&gt;");
				break;
			case '\'':
				sb.append("&#x27;");
				break;
			case '"':
				sb.append("&quot;");
				break;
			default:
				sb.append(c);
			}
		}
		return sb.toString();
	}

	/**
	 * 使用给定的分隔符, 将一个数组拼接成字符串
	 * 
	 * @param sp
	 *            分隔符
	 * @param array
	 *            要拼接的数组
	 * @return 拼接好的字符串
	 */
	public static <T> String join(CharSequence sp, T... array) {
		return Lang.concat(sp, array).toString();
	}

	/**
	 * 将字符串按半角逗号，拆分成数组，空元素将被忽略
	 * 
	 * @param s
	 *            字符串
	 * @return 字符串数组
	 */
	public static String[] splitIgnoreBlank(String s) {
		return Strings.splitIgnoreBlank(s, ",");
	}

	/**
	 * 根据一个正则式，将字符串拆分成数组，空元素将被忽略
	 * 
	 * @param s
	 *            字符串
	 * @param regex
	 *            正则式
	 * @return 字符串数组
	 */
	public static String[] splitIgnoreBlank(String s, String regex) {
		if (null == s)
			return null;
		String[] ss = s.split(regex);
		List<String> list = new LinkedList<String>();
		for (String st : ss) {
			if (isBlank(st))
				continue;
			list.add(trim(st));
		}
		return list.toArray(new String[list.size()]);
	}

	/**
	 * 将字符串根据转移字符转移
	 * 
	 * @param str
	 *            字符串
	 * @return 转移后的字符串
	 */
	public static String evalEscape(String str) {
		StringBuilder sb = new StringBuilder();
		char[] cs = str.toCharArray();
		for (int i = 0; i < cs.length; i++) {
			char c = cs[i];
			// 如果是转义字符
			if (c == '\\') {
				c = cs[++i];
				switch (c) {
				case 'n':
					sb.append('\n');
					break;
				case 'r':
					sb.append('\r');
					break;
				case 't':
					sb.append('\t');
					break;
				case 'b':
					sb.append('\b');
					break;
				case '\'':
				case '"':
				case '\\':
					sb.append(c);
					break;
				default:
					throw Lang.makeThrow("evalEscape invalid char[%d] '%c'  : %s", i, c, str);
				}
			}
			// 否则添加
			else {
				sb.append(c);
			}
		}
		return sb.toString();
	}

	/**
	 * @see #split(String, boolean, boolean, char...)
	 */
	public static String[] split(String str, boolean keepQuote, char... seps) {
		return split(str, keepQuote, false, seps);
	}

	/**
	 * 将字符串按照某个或几个分隔符拆分。 其中，遇到字符串 "..." 或者 '...' 并不拆分
	 * 
	 * @param str
	 *            要被拆分的字符串
	 * @param keepQuote
	 *            是否保持引号
	 * @param seps
	 *            分隔符
	 * @return 拆分后的数组
	 */
	public static String[] split(String str, boolean keepQuote, boolean keepBlank, char... seps) {
		List<String> list = new LinkedList<String>();
		char[] cs = str.toCharArray();
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < cs.length; i++) {
			char c = cs[i];
			// 遇到分隔符号
			if (Nums.isin(seps, c)) {
				if (keepBlank || !Strings.isBlank(sb)) {
					String s2 = sb.toString();
					if (!keepQuote)
						s2 = evalEscape(s2);
					list.add(s2);
					sb = new StringBuilder();
				}
			}
			// 如果是转义字符
			else if (c == '\\') {
				i++;
				if (keepQuote)
					sb.append(c);
				if (i < cs.length) {
					c = cs[i];
					sb.append(c);
				} else {
					break;
				}
			}
			// 字符串
			else if (c == '\'' || c == '"' || c == '`') {
				if (keepQuote)
					sb.append(c);
				while (++i < cs.length) {
					char c2 = cs[i];
					// 如果是转义字符
					if (c2 == '\\') {
						sb.append('\\');
						i++;
						if (i < cs.length) {
							c2 = cs[i];
							sb.append(c2);
						} else {
							break;
						}
					}
					// 退出字符串
					else if (c2 == c) {
						if (keepQuote)
							sb.append(c2);
						break;
					}
					// 其他附加
					else {
						sb.append(c2);
					}
				}
			}
			// 其他，计入
			else {
				sb.append(c);
			}
		}

		// 添加最后一个
		if (keepBlank || !Strings.isBlank(sb)) {
			String s2 = sb.toString();
			if (!keepQuote)
				s2 = evalEscape(s2);
			list.add(s2);
		}

		// 返回拆分后的数组
		return list.toArray(new String[list.size()]);
	}
	
	/**
	 * 判断是否是整数
	 * @param str
	 * @return
	 */
	public static boolean isNumeric(String str){ 
		   Pattern pattern = Pattern.compile("[0-9]*"); 
		   Matcher isNum = pattern.matcher(str);
		   if( !isNum.matches() ){
		       return false; 
		   } 
		   return true; 
		}
}
